package cn.edu.imau.zy.examination.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;


import cn.edu.imau.zy.examination.domain.ElQu;
import cn.edu.imau.zy.examination.domain.ElQuAnswer;
import cn.edu.imau.zy.examination.domain.ElQuRepo;
import cn.edu.imau.zy.examination.mapper.ElQuAnswerMapper;
import cn.edu.imau.zy.examination.mapper.ElQuMapper;
import cn.edu.imau.zy.examination.service.IElQuAnswerService;
import cn.edu.imau.zy.examination.service.IElQuRepoService;
import cn.edu.imau.zy.examination.service.IElQuService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.transaction.annotation.Transactional;


/**
 * 问题题目Service业务层处理
 *
 * @author xsc
 * @date 2021-05-08
 */
@Service
public class ElQuServiceImpl extends ServiceImpl<ElQuMapper, ElQu> implements IElQuService {

//    private ElQu

    @Autowired
    private IElQuService iElQuService;

    @Autowired
    private IElQuRepoService elQuRepoService;

    @Autowired
    private IElQuAnswerService elQuAnswerService;

    @Autowired
    private ElQuAnswerMapper elQuAnswerMapper;

    @Autowired
    private ElQuMapper elQuMapper;


    @Override
    public List<ElQu> queryList(Map<String, Object> params) {
        List<ElQu> elQus = elQuMapper.typeQuery(params);
        return elQus;
    }

    @Override
    public ElQu noCorrectElQu(String id) {
        // 选项
        List<ElQuAnswer> elQuAnswers = elQuAnswerMapper.noCorrect(id);

        ElQu byId = this.getById(id);
        byId.setEl(elQuAnswers);

        return byId;
    }

    @Override
    public ElQu infoElQu(String id) {
        ElQu elQu = new ElQu();

        // 根据条件查询
        LambdaQueryWrapper<ElQuAnswer> lqw = Wrappers.lambdaQuery();
        lqw.eq(ElQuAnswer::getQuId, id);

        System.out.println(id);

        List<ElQuAnswer> list = elQuAnswerService.list(lqw);
       // 提取正确答案
        for (ElQuAnswer elQuAnswer : list) {
            if (elQuAnswer.getIsRight() == 1) {
                elQu.getRow().add(elQuAnswer);
            }
        }
        ElQu qu = this.getById(id);

        elQu.setId(qu.getId());
        elQu.setContent(qu.getContent());
        elQu.setQuType(qu.getQuType());
        elQu.setRemark(qu.getRemark());
        elQu.setAnalysis(qu.getAnalysis());
        // 放入正确答案
        elQu.setEl(list);
        return elQu;
    }


    @Transactional
    public boolean saveQu(ElQu elQu) {
        long start = System.currentTimeMillis();
        System.out.println(elQu.toString());
        //保存答案
        List<ElQuAnswer> answersList = elQu.getEl();
        //  保存问题题目

        iElQuService.save(elQu);
        for (ElQuAnswer elQuAnswer : answersList) {
            // 存储正确答案
            elQuAnswer.setQuId(elQu.getId());
            for (ElQuAnswer quAnswer : elQu.getRow()) {
                if (quAnswer.getCorrect().equals(elQuAnswer.getCorrect())) {
                    elQuAnswer.setIsRight(1);
                    break;
                }
            }

            elQuAnswerService.save(elQuAnswer);
        }
        // 保存题库
        ElQuRepo elQuRepo = new ElQuRepo();
        elQuRepo.setQuId(elQu.getId());
        elQuRepo.setRepoId(elQu.getRepoId());
        elQuRepo.setQuType(elQu.getQuType());

        long end = System.currentTimeMillis();
        System.out.println("用时 ：" + (end - start));
        return elQuRepoService.save(elQuRepo);
    }

    @Override
    @Transactional
    public boolean upElQu(ElQu elQu) {

        LambdaQueryWrapper<ElQu> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ElQu::getId, elQu.getId());


        // 根据试题id修改
        iElQuService.update(elQu,queryWrapper);

        //保存答案
        List<ElQuAnswer> answersList = elQu.getEl();

        for (ElQuAnswer elQuAnswer : answersList) {
             QueryWrapper<ElQuAnswer> qu = new QueryWrapper<>();
            qu.eq("qu_id",elQu.getId());
            // 存储正确答案
            elQuAnswer.setQuId(elQu.getId());
            for (ElQuAnswer quAnswer : elQu.getRow()) {
                if (quAnswer.getCorrect().equals(elQuAnswer.getCorrect())) {
                    elQuAnswer.setIsRight(1);
                    break;
                }
            }
            elQuAnswerService.update(elQuAnswer,qu);
        }
        // 更新题库
        ElQuRepo elQuRepo = new ElQuRepo();

        LambdaQueryWrapper<ElQuRepo> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(ElQuRepo::getQuId,elQu.getId());
        wrapper.eq(ElQuRepo::getRepoId,elQu.getRepoId());

        elQuRepo.setQuId(elQu.getId());
        elQuRepo.setRepoId(elQu.getRepoId());
        elQuRepo.setQuType(elQu.getQuType());

        return elQuRepoService.update(elQuRepo,wrapper);
    }

    @Override
    public List<ElQu> typeQuery(Map<String, Object> params) {

        long start = System.currentTimeMillis();
        System.out.println(params.get("level"));
//        QueryWrapper<ElQu> wrapper = new QueryWrapper<>();
        List<ElQu> elQus = elQuMapper.typeQuery(params);

        long end = System.currentTimeMillis();
        System.out.println("用时 ：" + (end - start));
        return elQus;
    }

}
